home *** CD-ROM | disk | FTP | other *** search
/ CICA 1995 September (Japanese) / CICA Shareware for Windows CD-ROM (Walnut Creek) (September 1995) (Japanese) (Disc 2).iso / disc2 / nt / ntperf.exe / PERFTOOLS / SRC / PERFMON / DIALOGS.C_ / DIALOGS.C
Encoding:
C/C++ Source or Header  |  1993-06-05  |  17.4 KB  |  531 lines
  1. /*****************************************************************************
  2.  *
  3.  *  Dialogs.c - This module handles the Menu and Dialog user interactions.
  4.  *
  5.  *  Microsoft Confidential
  6.  *  Copyright (c) 1992-1993 Microsoft Corporation
  7.  *
  8.  ****************************************************************************/
  9.  
  10. #include <stdio.h>
  11.  
  12. #include "perfmon.h"
  13.  
  14. #include "alert.h"     // for SetAlertTimer, AlertData
  15. #include "graph.h"
  16. #include "cderr.h"
  17. #include "utils.h"
  18. #include "playback.h"  // for PlayingBackLog
  19. #include "grafdisp.h"  // for ToggleGraphRefresh
  20. #include "pmhelpid.h"  // Help IDs
  21.  
  22.  
  23. static BOOL          LocalManualRefresh ;
  24.  
  25.  
  26. /***************************************************************************/
  27. BOOL FAR PASCAL GraphOptionDlg(HWND hDlg, WORD msg, DWORD wParam, LONG lParam)
  28. /***************************************************************************/
  29. {
  30. static GRAPH_OPTIONS goLocalCopy ;
  31.  
  32. INT            iTimeMilliseconds ;
  33. TCHAR          szBuff[MiscTextLen] ;
  34. PGRAPHSTRUCT   lgraph;
  35.  
  36.    lParam ;
  37.    lgraph = pGraphs;
  38.  
  39.    switch(msg)
  40.       {
  41.  
  42.       case WM_INITDIALOG:
  43.  
  44.          dwCurrentDlgID = HC_PM_idDlgOptionChart ;
  45.  
  46.          // Init the Radio button, Check boxes and text fields.
  47.  
  48.          goLocalCopy.iGraphOrHistogram =
  49.             lgraph->gOptions.iGraphOrHistogram ;
  50.          if (lgraph->gOptions.iGraphOrHistogram == LINE_GRAPH)
  51.             CheckRadioButton(hDlg, ID_GRAPH, ID_HISTOGRAM, ID_GRAPH) ;
  52.          else
  53.             CheckRadioButton(hDlg, ID_GRAPH, ID_HISTOGRAM, ID_HISTOGRAM) ;
  54.  
  55.          CheckDlgButton(hDlg, ID_LEGEND, lgraph->gOptions.bLegendChecked) ;
  56.          if (!(lgraph->gOptions.bLegendChecked))
  57.             {
  58.             // can't display valuebar w/o legend
  59.             DialogEnable (hDlg, IDD_CHARTOPTIONSVALUEBAR, FALSE) ;
  60.             }
  61.  
  62.          CheckDlgButton(hDlg, ID_LABELS, lgraph->gOptions.bLabelsChecked) ;
  63.          CheckDlgButton(hDlg, ID_VERT_GRID, lgraph->gOptions.bVertGridChecked) ;
  64.          CheckDlgButton(hDlg, ID_HORZ_GRID, lgraph->gOptions.bHorzGridChecked) ;
  65.          CheckDlgButton(hDlg, IDD_CHARTOPTIONSVALUEBAR,
  66.             lgraph->gOptions.bStatusBarChecked) ;
  67.  
  68.          TSPRINTF(szBuff, TEXT("%d"), lgraph->gOptions.iVertMax) ;
  69.          SendDlgItemMessage(hDlg, ID_VERT_MAX, WM_SETTEXT, 0, (LONG) szBuff) ;
  70.  
  71.          TSPRINTF(szBuff, TEXT("%3.3f"), lgraph->gOptions.eTimeInterval) ;
  72.          SendDlgItemMessage(hDlg, IDD_CHARTOPTIONSINTERVAL, WM_SETTEXT, 0, (LONG) szBuff) ;
  73.  
  74.          // Pickup a local copy of the Graph Options.
  75.  
  76.          goLocalCopy = lgraph->gOptions ;
  77.          LocalManualRefresh = lgraph->bManualRefresh ;
  78.  
  79.          if (PlayingBackLog())
  80.             {
  81.             DialogEnable (hDlg, IDD_CHARTOPTIONSPERIODIC, FALSE) ;
  82.             DialogEnable (hDlg, IDD_CHARTOPTIONSUPDATETEXT, FALSE) ;
  83.             DialogEnable (hDlg, IDD_CHARTOPTIONSMANUALREFRESH, FALSE) ;
  84.             }
  85.          else
  86.             {
  87.             CheckRadioButton (hDlg,
  88.                IDD_CHARTOPTIONSMANUALREFRESH,
  89.                IDD_CHARTOPTIONSPERIODIC,
  90.                LocalManualRefresh ? IDD_CHARTOPTIONSMANUALREFRESH :
  91.                IDD_CHARTOPTIONSPERIODIC) ;
  92.             }
  93.  
  94.          if (lgraph->bManualRefresh || PlayingBackLog())
  95.             {
  96.             DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVALTEXT, FALSE) ;
  97.             DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVAL, FALSE) ;
  98.             }
  99.          else
  100.             {
  101.             DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVALTEXT, TRUE) ;
  102.             DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVAL, TRUE) ;
  103.             }
  104.  
  105.          EditSetLimit (GetDlgItem(hDlg, ID_VERT_MAX),
  106.             sizeof(szBuff) / sizeof(TCHAR) - 1) ;
  107.  
  108.          EditSetLimit (GetDlgItem(hDlg, IDD_CHARTOPTIONSINTERVAL),
  109.             ShortTextLen) ;
  110.  
  111.          WindowCenter (hDlg) ;
  112.          return(TRUE);
  113.  
  114.       case WM_COMMAND:
  115.          switch(LOWORD(wParam))
  116.             {
  117.             case ID_VERT_MAX:
  118.                if (HIWORD(wParam) == EN_CHANGE)
  119.                   {
  120.                   DialogText(hDlg, ID_VERT_MAX, szBuff) ;
  121.                   swscanf(szBuff, TEXT("%d"), &goLocalCopy.iVertMax) ;
  122.                   }
  123.                break ;
  124.  
  125.  
  126.             case IDD_CHARTOPTIONSINTERVAL:
  127.                if (HIWORD(wParam) == EN_CHANGE)
  128.                   {
  129.                   goLocalCopy.eTimeInterval =
  130.                      DialogFloat (hDlg, IDD_CHARTOPTIONSINTERVAL, NULL) ;
  131.                   }
  132.                break ;
  133.  
  134.             case IDD_CHARTOPTIONSPERIODIC:
  135.             case IDD_CHARTOPTIONSMANUALREFRESH:
  136.                // check if the Manual refresh is currently checked.
  137.                // Then toggle the ManualRefresh button
  138.                LocalManualRefresh =
  139.                   IsDlgButtonChecked (hDlg, IDD_CHARTOPTIONSMANUALREFRESH) ;
  140.                CheckRadioButton (hDlg,
  141.                   IDD_CHARTOPTIONSMANUALREFRESH,
  142.                   IDD_CHARTOPTIONSPERIODIC,
  143.                   LocalManualRefresh ? IDD_CHARTOPTIONSPERIODIC :
  144.                   IDD_CHARTOPTIONSMANUALREFRESH) ;
  145.  
  146.                // gray out time interval if necessary...
  147.                DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVALTEXT,
  148.                   LocalManualRefresh) ;
  149.                DialogEnable (hDlg, IDD_CHARTOPTIONSINTERVAL,
  150.                   LocalManualRefresh) ;
  151.                LocalManualRefresh = !LocalManualRefresh ;
  152.                break ;
  153.  
  154.             case IDD_CHARTOPTIONSVALUEBAR:
  155.                if (goLocalCopy.bStatusBarChecked == TRUE)
  156.                   goLocalCopy.bStatusBarChecked = FALSE ;
  157.                else
  158.                   goLocalCopy.bStatusBarChecked = TRUE ;
  159.                break ;
  160.  
  161.  
  162.             case ID_LEGEND:
  163.                if (goLocalCopy.bLegendChecked == TRUE)
  164.                   goLocalCopy.bLegendChecked = FALSE ;
  165.                else
  166.                   goLocalCopy.bLegendChecked = TRUE ;
  167.  
  168.                DialogEnable (hDlg, IDD_CHARTOPTIONSVALUEBAR,
  169.                   goLocalCopy.bLegendChecked) ;
  170.  
  171.                break ;
  172.  
  173.  
  174.             case ID_LABELS:
  175.                if (goLocalCopy.bLabelsChecked == TRUE)
  176.                   goLocalCopy.bLabelsChecked = FALSE ;
  177.                else
  178.                   goLocalCopy.bLabelsChecked = TRUE ;
  179.                break ;
  180.  
  181.  
  182.             case ID_VERT_GRID:
  183.                if (goLocalCopy.bVertGridChecked == TRUE)
  184.                   goLocalCopy.bVertGridChecked = FALSE ;
  185.                else
  186.                   goLocalCopy.bVertGridChecked = TRUE ;
  187.                break ;
  188.  
  189.  
  190.             case ID_HORZ_GRID:
  191.                if (goLocalCopy.bHorzGridChecked == TRUE)
  192.                   goLocalCopy.bHorzGridChecked = FALSE ;
  193.                else
  194.                   goLocalCopy.bHorzGridChecked = TRUE ;
  195.                break ;
  196.  
  197.  
  198.             case ID_GRAPH:
  199.             case ID_HISTOGRAM:
  200.                if (goLocalCopy.iGraphOrHistogram == BAR_GRAPH)
  201.                   {
  202.                   goLocalCopy.iGraphOrHistogram = LINE_GRAPH ;
  203.                   }
  204.                else
  205.                   {
  206.                   goLocalCopy.iGraphOrHistogram = BAR_GRAPH ;
  207.                   }
  208.                CheckRadioButton(hDlg, ID_GRAPH, ID_HISTOGRAM,
  209.                   goLocalCopy.iGraphOrHistogram == LINE_GRAPH ?
  210.                   ID_GRAPH : ID_HISTOGRAM) ;
  211.  
  212.                break ;
  213.  
  214.             case IDOK:
  215.                //  verify some numeric entries first
  216.                if (goLocalCopy.iVertMax > MAX_VERTICAL ||
  217.                    goLocalCopy.iVertMax < MIN_VERTICAL)
  218.                   {
  219.                   DlgErrorBox (hDlg, ERR_BADVERTMAX) ;
  220.                   SetFocus (DialogControl (hDlg, ID_VERT_MAX)) ;
  221.                   EditSetTextEndPos (hDlg, ID_VERT_MAX) ;
  222.                   return (FALSE) ;
  223.                   break ;
  224.                   }
  225.                if (goLocalCopy.eTimeInterval > MAX_INTERVALSEC ||
  226.                    goLocalCopy.eTimeInterval < MIN_INTERVALSEC)
  227.                   {
  228.                   DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  229.                   SetFocus (DialogControl (hDlg, IDD_CHARTOPTIONSINTERVAL)) ;
  230.                   EditSetTextEndPos (hDlg, IDD_CHARTOPTIONSINTERVAL) ;
  231.                   return (FALSE) ;
  232.                   break ;
  233.                   }
  234.  
  235.                // We need to send a size message to the main window
  236.                // so it can setup the redraw of the graph and legend.
  237.  
  238.                lgraph->gOptions.bLegendChecked    = goLocalCopy.bLegendChecked ;
  239.                lgraph->gOptions.bStatusBarChecked = goLocalCopy.bStatusBarChecked ;
  240.  
  241.                if (lgraph->gOptions.eTimeInterval != goLocalCopy.eTimeInterval
  242.                   && !LocalManualRefresh)
  243.                   {
  244.                   iTimeMilliseconds = (INT) (goLocalCopy.eTimeInterval * (FLOAT) 1000.0) ;
  245.                   pGraphs->gInterval = iTimeMilliseconds ;
  246.                   if (!PlayingBackLog())
  247.                      {
  248.                      SetGraphTimer(pGraphs) ;
  249.                      }
  250.                   lgraph->bManualRefresh = LocalManualRefresh ;
  251.  
  252.                   }
  253.                else if (LocalManualRefresh != lgraph->bManualRefresh)
  254.                   {
  255.                   ToggleGraphRefresh (hWndGraph) ;
  256.                   }
  257.                // Assign the local copy of the graph options to the
  258.                // global copy.
  259.  
  260.                lgraph->gOptions = goLocalCopy ;
  261.  
  262.                SizeGraphComponents (hWndGraph) ;
  263.                WindowInvalidate (hWndGraph) ;
  264.                dwCurrentDlgID = 0 ;
  265.                EndDialog (hDlg, 1) ;
  266.                return (TRUE) ;
  267.                break ;
  268.  
  269.  
  270.             case IDCANCEL:
  271.                dwCurrentDlgID = 0 ;
  272.                EndDialog(hDlg,0);
  273.                return(TRUE);
  274.  
  275.             case ID_HELP:
  276.                CallWinHelp (dwCurrentDlgID) ;
  277.                break ;
  278.  
  279.             default:
  280.                break;
  281.             }
  282.          break;
  283.  
  284.       default:
  285.          break;
  286.  
  287.       }
  288.    return(FALSE);
  289.    }
  290.  
  291.  
  292.  
  293.  
  294. DWORD          iIntervalMSecs ;
  295. BOOL           bSwitchToAlert ;
  296. BOOL           bNetworkAlert ;
  297.  
  298.  
  299. void static OnAlertOptionDlgInit (HWND hDlg, PALERT pAlert)
  300.    {
  301.    BOOL           EnableFlag ;
  302.  
  303.    iIntervalMSecs = pAlert->iIntervalMSecs ;
  304.    bNetworkAlert = pAlert->bNetworkAlert ;
  305.    bSwitchToAlert = pAlert->bSwitchToAlert ;
  306.    
  307.    LocalManualRefresh = pAlert->bManualRefresh ;
  308.    
  309.    if (PlayingBackLog())
  310.       {
  311.       // When playingback log, disable all controls except 
  312.       // the alert interval
  313.       //
  314.       EnableFlag = TRUE ;
  315.       DialogEnable (hDlg, IDD_ALERTOPTIONSMANUALREFRESH, FALSE) ;
  316.       DialogEnable (hDlg, IDD_ALERTOPTIONSPOPUP, FALSE) ;
  317.       DialogEnable (hDlg, IDD_ALERTOPTIONSNETWORKALERT, FALSE) ;
  318.       DialogEnable (hDlg, IDD_ALERTOPTIONSNETGROUPTEXT, FALSE) ;
  319.       DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAME, FALSE) ;
  320.       DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAMETEXT, FALSE) ;
  321.       }
  322.    else
  323.       {
  324.       EnableFlag = !LocalManualRefresh ;
  325.       DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAME, pAlert->bNetworkAlert) ;
  326.       DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAMETEXT, pAlert->bNetworkAlert) ;
  327.       }
  328.  
  329.    // setup the Update time interval group items
  330.    DialogSetInterval (hDlg, IDD_ALERTOPTIONSINTERVAL, iIntervalMSecs) ;
  331.    DialogEnable (hDlg, IDD_ALERTOPTIONSINTERVAL, EnableFlag) ;
  332.    DialogEnable (hDlg, IDD_ALERTOPTIONSINTERVALTEXT, EnableFlag) ;
  333.    CheckRadioButton(hDlg, IDD_ALERTOPTIONSMANUALREFRESH,
  334.       IDD_ALERTOPTIONSPERIODIC,
  335.       !EnableFlag ? IDD_ALERTOPTIONSMANUALREFRESH : IDD_ALERTOPTIONSPERIODIC) ;
  336.  
  337.    CheckDlgButton (hDlg, IDD_ALERTOPTIONSPOPUP, pAlert->bSwitchToAlert) ;
  338.    CheckDlgButton (hDlg, IDD_ALERTOPTIONSNETWORKALERT, pAlert->bNetworkAlert) ;
  339.  
  340.    if (pAlert->MessageName[0])
  341.       {
  342.       DialogSetString (hDlg, IDD_ALERTOPTIONSMSGNAME, pAlert->MessageName) ;
  343.       }
  344.          
  345.    EditSetLimit (GetDlgItem(hDlg, IDD_ALERTOPTIONSMSGNAME),
  346.       sizeof(pAlert->MessageName)/sizeof(TCHAR) - 1) ;
  347.  
  348.    dwCurrentDlgID = HC_PM_idDlgOptionAlert ;
  349.  
  350.    WindowCenter (hDlg) ;
  351.  
  352.    }  // OnAlertOptionDlgInit
  353.  
  354. BOOL FAR PASCAL AlertOptionDlg (HWND hDlg, WORD msg, 
  355.                                 DWORD wParam, LONG lParam)
  356.    {
  357.  
  358.    PALERT         pAlert ;
  359.  
  360.    switch(msg)
  361.       {
  362.  
  363.       case WM_INITDIALOG:
  364.          pAlert = (PALERT) lParam ;
  365.          OnAlertOptionDlgInit (hDlg, pAlert) ;
  366.          return(TRUE);
  367.  
  368.        case WM_COMMAND:
  369.          switch(LOWORD(wParam))
  370.             {
  371.             case IDOK:
  372.                {
  373.                FLOAT eTimeInterval ;
  374.  
  375.                pAlert = AlertData (hWndAlert) ;
  376.  
  377.                eTimeInterval = DialogFloat (hDlg, IDD_ALERTOPTIONSINTERVAL, NULL) ;
  378.  
  379.                if (eTimeInterval > MAX_INTERVALSEC ||
  380.                    eTimeInterval < MIN_INTERVALSEC)
  381.                   {
  382.                   DlgErrorBox (hDlg, ERR_BADTIMEINTERVAL) ;
  383.                   SetFocus (DialogControl (hDlg, IDD_ALERTOPTIONSINTERVAL)) ;
  384.                   EditSetTextEndPos (hDlg, IDD_ALERTOPTIONSINTERVAL) ;
  385.                   return (FALSE) ;
  386.                   break ;
  387.                   }
  388.  
  389.                eTimeInterval = eTimeInterval * (FLOAT) 1000.0 +
  390.                    (FLOAT) 0.5 ;
  391.  
  392.                iIntervalMSecs = (DWORD) eTimeInterval ;
  393.  
  394.                pAlert->bNetworkAlert = bNetworkAlert ;
  395.                pAlert->bSwitchToAlert = bSwitchToAlert ;
  396.  
  397.  
  398.                if (!PlayingBackLog())
  399.                   {
  400.                   DialogText (hDlg,
  401.                      IDD_ALERTOPTIONSMSGNAME,
  402.                      pAlert->MessageName) ;
  403.                   }
  404.  
  405.                dwCurrentDlgID = 0 ;
  406.                EndDialog (hDlg, 1) ;
  407.                }
  408.                break ;
  409.  
  410.             case IDCANCEL:
  411.                dwCurrentDlgID = 0 ;
  412.                EndDialog(hDlg,0);
  413.                return(TRUE);
  414.             
  415.             case IDD_ALERTOPTIONSPERIODIC:
  416.             case IDD_ALERTOPTIONSMANUALREFRESH:
  417.  
  418.                if (!PlayingBackLog())
  419.                   {
  420.                   // check if the Manual refresh is currently checked.
  421.                   // Then toggle the ManualRefresh button
  422.                   LocalManualRefresh =
  423.                      IsDlgButtonChecked (hDlg, IDD_ALERTOPTIONSMANUALREFRESH) ;
  424.  
  425.                   CheckRadioButton(hDlg,
  426.                      IDD_ALERTOPTIONSMANUALREFRESH,
  427.                      IDD_ALERTOPTIONSPERIODIC,
  428.                      LocalManualRefresh ? IDD_ALERTOPTIONSPERIODIC :
  429.                      IDD_ALERTOPTIONSMANUALREFRESH) ;
  430.  
  431.                      DialogEnable (hDlg,
  432.                         IDD_ALERTOPTIONSINTERVAL,
  433.                         LocalManualRefresh) ;
  434.  
  435.                      DialogEnable (hDlg,
  436.                         IDD_ALERTOPTIONSINTERVALTEXT,
  437.                         LocalManualRefresh) ;
  438.  
  439.                      LocalManualRefresh = !LocalManualRefresh ;
  440.                   }
  441.  
  442.                break ;
  443.  
  444.             case IDD_ALERTOPTIONSPOPUP:
  445.                bSwitchToAlert = !bSwitchToAlert ;
  446.                CheckDlgButton (hDlg, IDD_ALERTOPTIONSPOPUP, bSwitchToAlert) ;
  447.                break;
  448.  
  449.             case IDD_ALERTOPTIONSNETWORKALERT:
  450.                bNetworkAlert = !bNetworkAlert ;
  451.                CheckDlgButton (hDlg, IDD_ALERTOPTIONSNETWORKALERT, bNetworkAlert) ;
  452.                DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAME, bNetworkAlert) ;
  453.                DialogEnable (hDlg, IDD_ALERTOPTIONSMSGNAMETEXT, bNetworkAlert) ;
  454.  
  455.                if (bNetworkAlert)
  456.                   {
  457.                   SetFocus (GetDlgItem(hDlg, IDD_ALERTOPTIONSMSGNAME)) ;
  458.                   SendDlgItemMessage(hDlg, IDD_ALERTOPTIONSMSGNAME,
  459.                      EM_SETSEL, 0, 16) ;
  460.                   }
  461.                
  462.                break;
  463.  
  464.             case IDD_DISPLAYHELP:
  465.                CallWinHelp (dwCurrentDlgID) ;
  466.                break ;
  467.  
  468.             default:
  469.                break;
  470.             }
  471.          break;
  472.  
  473.  
  474.        default:
  475.           break;
  476.  
  477.       }
  478.  
  479.    return (FALSE);
  480.    }  // AlertOptionDlg
  481.  
  482.  
  483. BOOL DisplayAlertOptions (HWND hWndParent,
  484.                            HWND hWndAlert)
  485.    {  // DisplayAlertOptions
  486.    PALERT        pAlert ;
  487.  
  488.    pAlert = AlertData (hWndParent) ;
  489.  
  490.    if (DialogBoxParam (hInstance, idDlgAlertOptions, 
  491.                        hWndParent, (DLGPROC) AlertOptionDlg, 
  492.                        (LPARAM) pAlert))
  493.       {  // if
  494.       
  495.       if (PlayingBackLog())
  496.          {
  497.          if (pAlert->iIntervalMSecs != iIntervalMSecs)
  498.             {
  499.             // a new time interval, re-do the backing back log
  500.             // using the new value...
  501.             pAlert->iIntervalMSecs = iIntervalMSecs ;
  502.             DialogSetInterval (hWndAlert, IDD_ALERTINTERVAL, iIntervalMSecs) ;
  503.             if (pAlert->pLineFirst)
  504.                {
  505.                PlaybackAlert (hWndAlert, 0) ;
  506.                WindowInvalidate (hWndAlert) ;
  507.                }
  508.             }
  509.          }
  510.       else if (LocalManualRefresh != pAlert->bManualRefresh)
  511.          {
  512.          if (!LocalManualRefresh)
  513.             {
  514.             pAlert->iIntervalMSecs = iIntervalMSecs ;
  515.             DialogSetInterval (hWndAlert, IDD_ALERTINTERVAL, iIntervalMSecs) ;
  516.             }
  517.          ToggleAlertRefresh (hWndAlert) ;
  518.          }
  519.       else if (!LocalManualRefresh)
  520.          {
  521.          pAlert->iIntervalMSecs = iIntervalMSecs ;
  522.          SetAlertTimer (pAlert) ;
  523.          DialogSetInterval (hWndAlert, IDD_ALERTINTERVAL, iIntervalMSecs) ;
  524.          }
  525.       }  // if
  526.  
  527.    return (TRUE) ;
  528.    }  // DisplayAlertOptions
  529.  
  530. 
  531.